package qc.module.platform.api.controller;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import qc.common.core.enums.ColumnTypeEnum;
import qc.common.core.enums.DataManagementTypeEnum;
import qc.common.core.enums.DataTypeEnum;
import qc.common.core.enums.WhereConditionTypeEnum;
import qc.common.core.exception.QCPromptException;
import qc.common.core.json.JsonParserUtil;
import qc.common.core.utils.DateUtil;
import qc.common.core.utils.IdentifierUtil;
import qc.common.core.utils.SqlRunnerUtil;
import qc.common.core.utils.StringSplitUtil;
import qc.module.platform.dto.db.DBDto;
import qc.module.platform.dto.dbTable.DBTableDto;
import qc.module.platform.dto.dbTableColumn.DBTableColumnDto;
import qc.module.platform.dto.dbTableData.*;
import qc.module.platform.entity.QcDbTableColumn;
import qc.module.platform.mapper.DBTableColumnMapper;
import qc.module.platform.service.DbService;
import qc.module.platform.service.DbTableColumnService;
import qc.module.platform.service.DbTableDataService;
import qc.module.platform.service.DbTableService;

import java.sql.SQLException;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 数据库表数据Controller，提供公用的数据查询、保存接口
 * selectOne、selectAll、count、insert、update、delete、save
 *
 * @author QuCheng Tech
 * @since 2024/2/29
 */
@RestController
@RequestMapping("/dbtabledata")
public class DbTableDataController {
    private DbService dbService;
    private DbTableService dbTableService;
    private DbTableColumnService dbTableColumnService;
    private DbTableDataService dbTableDataService;

    @Autowired
    public void setDbService(DbService dbService) {
        this.dbService = dbService;
    }

    @Autowired
    public void setDbTableService(DbTableService dbTableService) {
        this.dbTableService = dbTableService;
    }

    @Autowired
    public void setDbTableColumnService(DbTableColumnService dbTableColumnService) {
        this.dbTableColumnService = dbTableColumnService;
    }

    @Autowired
    public void setDbTableDataService(DbTableDataService dbTableDataService) {
        this.dbTableDataService = dbTableDataService;
    }

    /***
     * 数据保存，根据数据值判断是否存在，存在时修改，不存在时新增
     *
     * @param data 要保存的数据
     * @return java.lang.String
     * @author QuCheng Tech
     * @since 2024/2/29
     */
    @PostMapping(value = "/save")
    public String save(@RequestBody DBTableDataOperateDto data) {
        return operateData(data, DataManagementTypeEnum.SAVE);
    }

    /***
     * 数据新增
     *
     * @param data 要新增的数据
     * @return java.lang.String
     * @author QuCheng Tech
     * @since 2024/2/29
     */
    @PostMapping(value = "/insert")
    public String insert(@RequestBody DBTableDataOperateDto data) {
        return operateData(data, DataManagementTypeEnum.INSERT);
    }

    /***
     * 数据修改
     *
     * @param data 要修改的数据
     * @return java.lang.String
     * @author QuCheng Tech
     * @since 2024/2/29
     */
    @RequestMapping(value = "/update", method = {RequestMethod.PUT, RequestMethod.POST})
    public String update(@RequestBody DBTableDataOperateDto data) {
        return operateData(data, DataManagementTypeEnum.UPDATE);
    }

    /***
     * 删除数据
     *
     * @param data 删除的数据，指定表编码和主键键值对信息
     * @return java.lang.String
     * @author QuCheng Tech
     * @since 2024/3/7
     */
    @RequestMapping(value = "/delete", method = {RequestMethod.DELETE, RequestMethod.POST})
    public String delete(@RequestBody DBTableDataOperateDto data) {
        return operateData(data, DataManagementTypeEnum.DELETE);
    }

    /***
     * 数据操作，根据指定的操作类型进行处理，可以进行insert、update、delete
     *
     * @param data 要保存的数据
     * @param opType 保存类型
     * @return java.lang.String
     * @author QuCheng Tech
     * @since 2024/2/29
     */
    String operateData(DBTableDataOperateDto data, DataManagementTypeEnum opType) {
        if (data == null)
            return "操作数据对象不能为空";
        if (StringUtils.isBlank(data.getTablecode()))
            return "操作数据指定的数据库表不能为空";
        if (data.getData() == null || data.getData().size() < 0x1)
            return "操作数据的数据值集合不能为空";
        //对传入的数据键值对进行处理，去除key中的空格，统一使用小写，方便后面进行查找和获取值
        Map<String, String> inputFormData = new HashMap<>();
        for (Map.Entry<String, String> entry : data.getData().entrySet()) {
            if (StringUtils.isNotBlank(entry.getKey())) {
                inputFormData.put(entry.getKey().trim().toLowerCase(Locale.ROOT), entry.getValue());
            }
        }
        //如果传入的保存类型为自动判断，再获取data中的保存类型进行判断一次
        if (opType == DataManagementTypeEnum.SAVE && (data.getOperatetype() == DataManagementTypeEnum.INSERT.getIndex() || data.getOperatetype() == DataManagementTypeEnum.UPDATE.getIndex())) {
            for (DataManagementTypeEnum item : DataManagementTypeEnum.values()) {
                if (item.getIndex() == data.getOperatetype()) {//判断序号使用getIndex，判断内容使用getName
                    opType = item;
                    break;
                }
            }
        }

        //获取数据库表信息，根据表获取数据库连接信息和列信息
        DBTableDto dbTable = null;
        try {
            dbTable = dbTableService.get(data.getTablecode());
        } catch (QCPromptException e) {
            return e.getMessage();
        }
        if (dbTable == null)
            return "操作数据时获取到的数据库表信息为空，无法进行保存操作";

        DBDto db = null;
        try {
            db = dbService.get(dbTable.getDb());
        } catch (QCPromptException e) {
            return e.getMessage();
        }
        if (db == null)
            return "操作数据时获取到的数据库信息为空，无法进行保存操作";
        //数据库连接信息
        String dbUrl = "";
        String dbUser = "";
        String dbPassword = "";
        //解析数据库连接信息
        String dbConJsonString = db.getCon();
        if (StringUtils.isNotBlank(dbConJsonString)) {
            //Json对象进行获取
            dbUrl = JsonParserUtil.getString(dbConJsonString, "url");
            dbUser = JsonParserUtil.getString(dbConJsonString, "user");
            dbPassword = JsonParserUtil.getString(dbConJsonString, "password");
        }
        //查询数据库表列信息，如果没有列信息不能进行数据新增和修改操作
        try {
            //查询出所有的列，由前端进行判断显示
            List<QcDbTableColumn> tableColumns = dbTableColumnService.getTableColumnEntitys(data.getTablecode(), false,"qrodr");
            if (tableColumns == null || tableColumns.size() < 0x1)
                return "操作数据时获取到的数据库列信息为空，无法进行保存操作";

            //在此可以添加逐个遍历列，获取对应列传入的值，对值的长度、有效性进行判断验证
            //根据列的数据类型进行相应转换
            Map<String, Object> whereData = new HashMap<>();
            Map<String, Object> fieldData = new HashMap<>();
            for (QcDbTableColumn column : tableColumns) {
                String fieldCode = column.getCode().trim().toLowerCase(Locale.ROOT);//方便后面进行匹配统一使用小写进行判断
                Object fieldValue = null;
                //获取字段的数据值，如果有传入值使用传入值；否则保持为null
                if (inputFormData.containsKey(fieldCode) && inputFormData.get(fieldCode) != null) {
                    String inputStringValue = inputFormData.get(fieldCode);
                    System.out.println("遍历数据库表列，从输入数据中获取字段值，code=" + fieldCode + " name=" + column.getName() + " inputStringValue=" + inputStringValue);
                    //如果字符串为空（不包含空格字符串），认为传入数据没有该字段数据
                    if (StringUtils.isNotEmpty(inputStringValue)) {
                        //根据列的数据类型将字段的值转换为对应的数据类型
                        switch (column.getDatatype()) {
                            case DATE:
                                fieldValue = DateUtil.parseDate(inputStringValue);
                                break;
                            case INT:
                                fieldValue = Integer.parseInt(inputStringValue);
                                break;
                            case FLOAT:
                                fieldValue = Float.parseFloat(inputStringValue);
                                break;
                            case BOOL:
                                //字符串为0或者false时返回false，其他返回true
                                if (StringUtils.equalsIgnoreCase("0", inputStringValue) || StringUtils.equalsIgnoreCase("false", inputStringValue))
                                    fieldValue = false;
                                else
                                    fieldValue = true;
                                break;
                            default:
                                fieldValue = inputStringValue;
                                break;
                        }
                    }
                }

                //数据操作类型为新增、修改、保存（可能是修改）、删除时需要有主键数据判断
                if (opType == DataManagementTypeEnum.INSERT || opType == DataManagementTypeEnum.UPDATE || opType == DataManagementTypeEnum.SAVE || opType == DataManagementTypeEnum.DELETE) {
                    //如果列时主键列，判断传入的数据值不能为空；添加到where条件数据集合
                    if (column.getIsprimary() == true) {
                        //判断有主键列时，不管新增还是修改主键列如果没有默认值时值不能为空
                        if (fieldValue == null && StringUtils.isBlank(column.getDefaultval()))
                            return "操作数据时列[" + column.getName() + "]为主键，值不能为空，无法进行保存操作";
                        //如果条件对应的值为null，无法作为主键列？？
                        whereData.put(fieldCode, fieldValue);
                    }
                }

                //如果最终得到的字段值为null，表示没有传入对应字段的值，不进行赋值；比如修改时不修改该字段，或者新增时默认保持为空
                //字段数据仅需要在insert、update、save操作时进行赋值，select和delete不需要赋值
                if (opType == DataManagementTypeEnum.INSERT || opType == DataManagementTypeEnum.UPDATE || opType == DataManagementTypeEnum.SAVE) {
                    if (fieldValue != null) {
                        fieldData.put(fieldCode, fieldValue);
                    }
                }

                //对重置值的列进行赋值，重置值的列在新增和修改时均需要对值进行重新赋值
                if (opType == DataManagementTypeEnum.INSERT || opType == DataManagementTypeEnum.UPDATE || opType == DataManagementTypeEnum.SAVE) {
                    if (column.getEfreset() == true) {
                        //如果列有默认值使用默认值，如果没有默认值使用传入值（传入值为空也使用传入值）
                        Object fieldDefaultValue = getFieldDefaultValue(column.getDatatype(), column.getColtype(), column.getDefaultval(), column.getValrange(), data.getObjid(), data.getObjname(), data.getObjparam(), data.getUserid(), data.getUsername());
                        fieldData.put(fieldCode, fieldDefaultValue == null ? fieldValue : fieldDefaultValue);
                    }
                }
            }
            //根据操作类型进行不同处理
            if (opType == DataManagementTypeEnum.DELETE) {
                try {
                    boolean deleteDataResult = SqlRunnerUtil.deleteData(dbUrl, dbUser, dbPassword, data.getTablecode(), whereData);
                } catch (SQLException e) {
                    //执行删除sql语句时异常，返回异常提示信息
                    return e.getMessage();
                }
            } else if (opType == DataManagementTypeEnum.INSERT || opType == DataManagementTypeEnum.UPDATE || opType == DataManagementTypeEnum.SAVE) {
                //判断是否为新增操作：指定为新增、或者未指定操作类型且（数据不存在、表没有任何主键列信息）
                //判断得到最终本次保存是新增还是修改
                boolean isInsert = false;
                if (opType == DataManagementTypeEnum.INSERT) {
                    isInsert = true;
                } else if (opType == DataManagementTypeEnum.SAVE) {
                    //判断列集合中是否有主键列信息--根据前面处理的主键where条件数据判断
                    if (whereData == null || whereData.size() < 0x1) {
                        isInsert = true;
                    } else {
                        try {
                            if (SqlRunnerUtil.hasExistData(dbUrl, dbUser, dbPassword, data.getTablecode(), whereData) == false)
                                isInsert = true;
                        } catch (SQLException e) {
                            //查询是否存在已有数据时异常，返回异常提示信息
                            return e.getMessage();
                        }
                    }
                }

                //根据保存类型分别处理
                if (isInsert) {
                    //新增数据时再对列集合中默认值的列没有值的进行赋值
                    List<QcDbTableColumn> hasDefaultValueColumns = tableColumns.stream().filter(p -> StringUtils.isNotBlank(p.getDefaultval())).collect(Collectors.toList());
                    if (hasDefaultValueColumns != null && hasDefaultValueColumns.size() > 0x0) {
                        for (QcDbTableColumn column : hasDefaultValueColumns) {
                            String fieldCode = column.getCode().trim().toLowerCase(Locale.ROOT);//方便后面进行匹配统一使用小写进行判断
                            Object fieldValue = null;
                            //获取字段的数据值，如果有传入值使用传入值；否则保持为null
                            if (fieldData.containsKey(fieldCode) && fieldData.get(fieldCode) != null)
                                fieldValue = fieldData.get(fieldCode);
                            System.out.println("本次操作判定为insert数据，遍历有默认值的数据库表列，对没有默认值的列进行赋值，code=" + fieldCode + " name=" + column.getName() + " fieldValue=" + fieldValue);

                            if (fieldValue == null && StringUtils.isNotBlank(column.getDefaultval())) {
                                //根据列的数据类型分别进行判断处理得到默认值
                                fieldValue = getFieldDefaultValue(column.getDatatype(), column.getColtype(), column.getDefaultval(), column.getValrange(), data.getObjid(), data.getObjname(), data.getObjparam(), data.getUserid(), data.getUsername());
                            }
                            //如果最终得到的字段值不为null，加入到新建数据的键值对中
                            if (fieldValue != null)
                                fieldData.put(fieldCode, fieldValue);
                        }
                    }
                    //新增数据
                    try {
                        boolean insertResult = SqlRunnerUtil.insertData(dbUrl, dbUser, dbPassword, data.getTablecode(), fieldData);
                    } catch (SQLException e) {
                        //insert语句执行异常
                        return e.getMessage();
                    }
                } else {
                    //如果修改没有条件进行提示
                    if (whereData == null || whereData.size() < 0x1)
                        return "修改数据没有指定任何条件，无法进行修改操作";
                    //修改数据时，特殊的列不进行修改；如写入时间、主键列
                    for (QcDbTableColumn column : tableColumns) {
                        String fieldCode = column.getCode().trim().toLowerCase(Locale.ROOT);//方便后面进行匹配统一使用小写进行判断
                        //判定在修改数据键值对中是否存在当前列
                        if (fieldData.containsKey(fieldCode)) {
                            //如果是主键列不能修改，从修改数据键值对中移除
                            if (column.getIsprimary()) {
                                System.out.println("本次操作判定为update数据，主键列不进行修改，从修改数据中移除，code=" + fieldCode + " name=" + column.getName());
                                fieldData.remove(fieldCode);
                            }
                            //如果列类型是写入时间，不能进行修改，从修改数据键值对中移除
                            if (column.getColtype() == ColumnTypeEnum.TIME_IN) {
                                System.out.println("本次操作判定为update数据，写入时间列等特殊列不进行修改，从修改数据中移除，code=" + fieldCode + " name=" + column.getName());
                                fieldData.remove(fieldCode);
                            }
                        }
                    }
                    //修改数据
                    try {
                        boolean updateResult = SqlRunnerUtil.updateData(dbUrl, dbUser, dbPassword, data.getTablecode(), fieldData, whereData);
                    } catch (SQLException e) {
                        //update语句执行异常
                        return e.getMessage();
                    }
                }

            } else if (opType == DataManagementTypeEnum.SELECT) {
                //查询暂时不做处理
            }
        } catch (QCPromptException e) {
            //查询数据库表列信息时异常
            return e.getMessage();
        }

        return null;
    }

    /***
     * 获取字段的默认值，根据字段的数据类型、列类型进行不同的处理
     *
     * @param dataType 数据类型
     * @param columnType 列类型
     * @param defaultValueString 默认值字符串
     * @param valueRangeString 取值范围：在列类型为参数值-80表示参数名称，列类型为字典时表示字典名称
     * @param objectId 对象ID/编码，可以为空
     * @param objectName 对象名称，可以为空
     * @param objectParams 对象参数json，可以为空
     * @param userId 操作用户ID，可以为空
     * @param userName 操作用户名称，可以为空
     * @return java.lang.Object
     * @author QuCheng Tech
     * @since 2024/3/1
     */
    Object getFieldDefaultValue(DataTypeEnum dataType, ColumnTypeEnum columnType, String defaultValueString, String valueRangeString, String objectId, String objectName, String objectParams, String userId, String userName) {
        System.out.println("getFieldDefaultValue dataType=" + dataType.getName() + " columnType=" + columnType.getName() + " defaultValueString=" + defaultValueString + " objectId=" + objectId + " objectName=" + objectName + " objectParams=" + objectParams + " userId=" + userId + " userName=" + userName);
        //先根据列类型进行对应值的提取，再根据数据类型进行转换返回
        switch (columnType) {
            case ID_INT:
                //int型的id不需要判断数据类型，无法生成
                return null;
            //break;
            case ID_UUID_36:
                //uuid不需要判断数据类型，直接生成后返回
                return IdentifierUtil.randomUUID();
            //break;
            case ID_UUID_32:
                //uuid不需要判断数据类型，直接生成后返回
                return IdentifierUtil.simpleUUID();
            //break;
            case OBJECT_ID:
                //对象ID或者编码，可以为整数或字符串
                if (StringUtils.isNotBlank(objectId)) {
                    if (dataType == DataTypeEnum.INT) {
                        return Integer.parseInt(objectId);
                    }
                    return objectId;
                }
                break;
            case OBJECT_NAME:
                //对象名称只能是字符串，直接返回
                if (StringUtils.isNotBlank(objectName))
                    return objectName;
                break;
            case TIME_IN:
            case TIME_UPDATE:
                //写入时间和更新时间都使用当前时间，不需要判断数据类型，直接返回
                //可以增加根据defaultValueString计算时间，如要获取当前日期、月份、年份等
                return DateUtil.getNowDate();
            //break;
            case PARAM_VALUE:
                //取参数值时，valueRangeString为获取参数名，如果参数名和参数键值对没有返回null
                if (StringUtils.isNotBlank(valueRangeString)) {
                    if (StringUtils.isNotBlank(objectParams)) {
                        //json字符串中获取参数值，只获取根节点对象中的参数名称
                        String paramValue = JsonParserUtil.getString(objectParams, valueRangeString);
                        if (StringUtils.isNotBlank(paramValue)) {
                            //根据数据类型进行转换返回
                            switch (dataType) {
                                case DATE:
                                    return DateUtil.parseDate(paramValue);
                                //break;
                                case INT:
                                    return Integer.parseInt(paramValue);
                                //break;
                                case FLOAT:
                                    return Float.parseFloat(paramValue);
                                //break;
                                case BOOL:
                                    //字符串为0或者false时返回false，其他返回true
                                    if (StringUtils.equalsIgnoreCase("0", paramValue) || StringUtils.equalsIgnoreCase("false", paramValue))
                                        return false;
                                    else
                                        return true;
                                    //break;
                                default:
                                    return paramValue;
                                //break;
                            }
                        }
                    }
                }
                return null;
            //break;
            case USER_ID:
                //用户ID可以转换为字符串、整数数据类型，默认使用字符串
                if (StringUtils.isNotBlank(userId)) {
                    if (dataType == DataTypeEnum.INT) {
                        return Integer.parseInt(userId);
                    }
                    return userId;
                }
                break;
            case USER_NAME:
                //用户名固定为字符串，不判断数据类型，直接返回
                if (StringUtils.isNotBlank(objectName))
                    return userName;
                break;
            default:
                //列类型为其他类型，根据数据类型和默认值处理
                //在后面统一处理
                break;
        }

        //如果根据类类型中没有返回结果，返回默认值字符串作为结果
        if (StringUtils.isNotBlank(defaultValueString)) {
            switch (dataType) {
                case DATE:
                    return DateUtil.parseDate(defaultValueString);
                //break;
                case INT:
                    return Integer.parseInt(defaultValueString);
                //break;
                case FLOAT:
                    return Float.parseFloat(defaultValueString);
                //break;
                case BOOL:
                    //字符串为0或者false时返回false，其他返回true
                    if (StringUtils.equalsIgnoreCase("0", defaultValueString) || StringUtils.equalsIgnoreCase("false", defaultValueString))
                        return false;
                    else
                        return true;
                    //break;
                default:
                    return defaultValueString;
                //break;
            }
        }

        return null;
    }

    /***
     * 获取指定表的查询条件表单DTO
     *
     * @param id 数据库表编码
     * @return qc.module.platform.dto.dbTableData.DBTableDataGetQueryConditionFormDto
     * @author QuCheng Tech
     * @since 2024/3/7
     */
    @GetMapping("/condition")
    public DBTableDataGetQueryConditionFormDto getQueryConditionByParam(@RequestParam(required = true) String id) throws Exception {
        return getTableQueryConditionForm(id);
    }

    /***
     * 获取指定表的查询条件表单DTO
     *
     * @param id 数据库表编码
     * @return qc.module.platform.dto.dbTableData.DBTableDataGetQueryConditionFormDto
     * @author QuCheng Tech
     * @since 2024/3/7
     */
    @GetMapping("/condition/{id}")
    public DBTableDataGetQueryConditionFormDto getQueryConditionByPath(@PathVariable(required = true) String id) throws Exception {
        return getTableQueryConditionForm(id);
    }

    /***
     * 获取指定表的查询条件表单数据DTO
     *
     * @param tableCode 数据库表编码
     * @return qc.module.platform.dto.dbTableData.DBTableDataGetQueryConditionFormDto
     * @author QuCheng Tech
     * @since 2024/3/7
     */
    DBTableDataGetQueryConditionFormDto getTableQueryConditionForm(String tableCode) throws QCPromptException, SQLException {
        if (StringUtils.isBlank(tableCode))
            throw new QCPromptException("指定的数据库表编码不能为空");

        DBTableDataGetQueryConditionFormDto result = new DBTableDataGetQueryConditionFormDto();
        result.setTablecode(tableCode);

        //获取数据库表列--仅获取查询条件表单中的列信息
        List<QcDbTableColumn> conditionColumns = dbTableColumnService.getShowInConditionFormColumnEntitys(tableCode);
        if (conditionColumns != null && conditionColumns.size() > 0x0) {
            List<DBTableDataGetQueryConditionFormItemDto> items = new ArrayList<>();

            //遍历查询条件表单项进行处理
            for (QcDbTableColumn column : conditionColumns) {
                DBTableDataGetQueryConditionFormItemDto item = new DBTableDataGetQueryConditionFormItemDto();
                
                item.setCode(column.getCode());
                item.setName(column.getName());
                item.setDatatype(column.getDatatype().getIndex());
                item.setColtype(column.getColtype().getIndex());
                item.setCmptype(column.getQccmptype().getIndex());
                item.setNotnull(column.getQcnotnull());
                item.setFormatstr(column.getFormatstr());
                //查询条件表单默认值--先不进行赋值
                //item.setDefaultval(null);
                //处理表单项的待选择数据
                item.setOptions(dbTableDataService.getColumnOptions(column.getColtype(), column.getValrange()));

                items.add(item);
            }

            result.setItems(items);
        }

        return result;
    }

    /***
     * 根据条件查询数据
     *
     * @param condition 查询条件
     * @return qc.module.platform.dto.dbTableData.DBTableDataQueryResultDto
     * @author QuCheng Tech
     * @since 2024/3/7
     */
    @RequestMapping(value = "/query", method = {RequestMethod.GET, RequestMethod.POST})
    public DBTableDataQueryResultDto query(@RequestBody DBTableDataQueryConditionDto condition) throws QCPromptException, SQLException {
        //查询条件中可以只有指定的表编码，没有查询条件表单输入数据
        //查询数据时固定将所有列数据都查出，根据显示在表格列进行查询可能会导致修改时对表单赋值时数据不完整（获取再调用一次后台接口根据主键列进行数据查询）
        if (condition == null)
            throw new QCPromptException("查询数据的条件对象不能为空");
        if (StringUtils.isBlank(condition.getTablecode()))
            throw new QCPromptException("查询数据的条件中数据库表编码不能为空");

        DBTableDto table = dbTableService.get(condition.getTablecode());
        if (table == null)
            throw new QCPromptException("查询数据的条件中数据库表编码信息不存在");

        DBTableDataQueryResultDto result = new DBTableDataQueryResultDto();
        result.setTable(table);
        //获取表列信息，先查询出实体类集合，方便后面的判断
        List<QcDbTableColumn> columnEntitys = dbTableColumnService.getTableColumnEntitys(condition.getTablecode(), false,"qrodr");
        //如果列信息为空，无法进行后续的处理
        if (columnEntitys != null && columnEntitys.size() > 0x0) {
            List<DBTableColumnDto> items = new ArrayList<>();

            for (QcDbTableColumn column : columnEntitys) {
                DBTableColumnDto columnDto = DBTableColumnMapper.MAPPER.toDto(column);
                //列的待选择数据需要单独处理
                columnDto.setOptions(dbTableDataService.getColumnOptions(column.getColtype(), column.getValrange()));

                items.add(columnDto);
            }

            result.setColumns(items);
        }

        //获取数据库信息
        //数据库连接信息
        String dbUrl = "";
        String dbUser = "";
        String dbPassword = "";
        DBDto db = dbService.get(table.getDb());
        if (db != null) {
            //解析数据库连接信息
            String dbConJsonString = db.getCon();
            if (StringUtils.isNotBlank(dbConJsonString)) {
                //Json对象进行获取
                dbUrl = JsonParserUtil.getString(dbConJsonString, "url");
                dbUser = JsonParserUtil.getString(dbConJsonString, "user");
                dbPassword = JsonParserUtil.getString(dbConJsonString, "password");
            }
        }

        //查询结果的排序问题处理：
        StringBuilder sbSql = new StringBuilder("select * from " + condition.getTablecode());
        //根据查询条件构造sql中的where条件数据
        if (condition.getItems() != null && condition.getItems().size() > 0x0) {
            sbSql.append(" where ");
            for (DBTableDataQueryConditionItemDto conditionItem : condition.getItems()) {
                //如果有值才加入where条件
                if (StringUtils.isNotBlank(conditionItem.getCode()) && StringUtils.isNotBlank(conditionItem.getVal1())) {
                    String columnName = conditionItem.getCode().trim().toLowerCase(Locale.ROOT);
                    Optional<QcDbTableColumn> column = columnEntitys.stream().filter(p -> StringUtils.equalsIgnoreCase(p.getCode(), columnName)).findFirst();
                    //有对应的列信息，并且列的数据类型不是二进制对象（无法进行对比）
                    if (column != null && column.isPresent() && column.get().getDatatype() != DataTypeEnum.BLOB) {
                        //每个条件：fieldName compareType fieldValue;compareType根据列的条件比较类型得到，fieldValue根据列的数据类型处理（是否需要加单撇号）
                        sbSql.append(columnName);
                        //先判断查询条件的比较类型
                        switch (column.get().getQccmptype()) {
                            case EQ:
                                sbSql.append(" = ");
                                break;
                            case NE:
                                sbSql.append(" <> ");
                                break;
                            case GT:
                                sbSql.append(" > ");
                                break;
                            case GE:
                                sbSql.append(" >= ");
                                break;
                            case LT:
                                sbSql.append(" < ");
                                break;
                            case LE:
                                sbSql.append(" <= ");
                                break;
                            case LIKE:
                                sbSql.append(" like ");
                                break;
                            case LIKE_LEFT:
                                sbSql.append(" like ");
                                break;
                            case LIKE_RIGHT:
                                sbSql.append(" like ");
                                break;
                            case IN:
                                sbSql.append(" in ");
                                break;
                            case IN_NOT:
                                sbSql.append(" not in ");
                                break;
                            case BETWEEN:
                                sbSql.append(" between ");
                                break;
                            case BETWEEN_NOT:
                                sbSql.append(" not between ");
                                break;
                            default:
                                //未实现的条件处理，抛出异常提示
                                break;
                        }

                        //列数据类型分为：数值、日期、字符串3种类型分别判断处理，枚举类型根据传入的值判断采用数值还是字符串处理
                        boolean isDataTypeString = true;//是否当做字符串处理
                        if (column.get().getDatatype() == DataTypeEnum.INT
                                || column.get().getDatatype() == DataTypeEnum.FLOAT
                                || column.get().getDatatype() == DataTypeEnum.BOOL
                        ) {
                            isDataTypeString = false;
                        }

                        if (column.get().getDatatype() == DataTypeEnum.DATE) {
                            //列类型是日期类型，单独处理
                            Date dateValue1 = DateUtil.parseDate(conditionItem.getVal1());
                            if (dateValue1 == null)
                                throw new QCPromptException("查询数据的条件中名称为：" + column.get().getName() + "的列对比值：" + conditionItem.getVal1() + "不是有效的日期时间，无法完成查询操作");
                            if (column.get().getQccmptype() == WhereConditionTypeEnum.LIKE
                                    || column.get().getQccmptype() == WhereConditionTypeEnum.LIKE_LEFT
                                    || column.get().getQccmptype() == WhereConditionTypeEnum.LIKE_RIGHT) {
                                //like '%val%'
                                if (column.get().getQccmptype() == WhereConditionTypeEnum.LIKE_LEFT)
                                    sbSql.append("'%" + DateUtil.getDateTimeString(dateValue1) + "'");
                                else if (column.get().getQccmptype() == WhereConditionTypeEnum.LIKE_LEFT)
                                    sbSql.append("'" + DateUtil.getDateTimeString(dateValue1) + "%'");
                                else
                                    sbSql.append("'%" + DateUtil.getDateTimeString(dateValue1) + "%'");
                            } else if (column.get().getQccmptype() == WhereConditionTypeEnum.IN
                                    || column.get().getQccmptype() == WhereConditionTypeEnum.IN_NOT) {
                                //in、not in (,,,)
                                sbSql.append("(");
                                String[] strs = StringSplitUtil.Split(conditionItem.getVal1(), true);
                                if (strs != null && strs.length > 0x0) {
                                    for (String s : strs) {
                                        sbSql.append(s + ",");
                                    }
                                    //移除最后的逗号，
                                    sbSql.setLength(sbSql.length() - 1);
                                }
                                sbSql.append(")");
                            } else if (column.get().getQccmptype() == WhereConditionTypeEnum.BETWEEN
                                    || column.get().getQccmptype() == WhereConditionTypeEnum.BETWEEN_NOT) {
                                //beween value1 and value2
                                Date dateValue2 = DateUtil.parseDate(conditionItem.getVal2());
                                if (dateValue2 == null)
                                    throw new QCPromptException("查询数据的条件中名称为：" + column.get().getName() + "的列对比值：" + conditionItem.getVal2() + "不是有效的日期时间，无法完成查询操作");
                                sbSql.append("'" + DateUtil.getDateTimeString(dateValue1) + "' and '" + DateUtil.getDateTimeString(dateValue2) + "'");
                            } else {
                                //其他当做等于、大于和小于判断
                                sbSql.append("'" + DateUtil.getDateTimeString(dateValue1) + "'");
                            }
                        } else {
                            if (isDataTypeString) {
                                //当做字符串类型处理
                                if (column.get().getQccmptype() == WhereConditionTypeEnum.LIKE
                                        || column.get().getQccmptype() == WhereConditionTypeEnum.LIKE_LEFT
                                        || column.get().getQccmptype() == WhereConditionTypeEnum.LIKE_RIGHT) {
                                    //like '%val%'
                                    if (column.get().getQccmptype() == WhereConditionTypeEnum.LIKE_LEFT)
                                        sbSql.append("'%" + conditionItem.getVal1() + "'");
                                    else if (column.get().getQccmptype() == WhereConditionTypeEnum.LIKE_LEFT)
                                        sbSql.append("'" + conditionItem.getVal1() + "%'");
                                    else
                                        sbSql.append("'%" + conditionItem.getVal1() + "%'");
                                } else if (column.get().getQccmptype() == WhereConditionTypeEnum.IN
                                        || column.get().getQccmptype() == WhereConditionTypeEnum.IN_NOT) {
                                    //in、not in (,,,)
                                    sbSql.append("(");
                                    String[] strs = StringSplitUtil.Split(conditionItem.getVal1(), true);
                                    if (strs != null && strs.length > 0x0) {
                                        for (String s : strs) {
                                            sbSql.append("'" + s + "',");
                                        }
                                        //移除最后的逗号，
                                        sbSql.setLength(sbSql.length() - 1);
                                    }
                                    sbSql.append(")");
                                } else if (column.get().getQccmptype() == WhereConditionTypeEnum.BETWEEN
                                        || column.get().getQccmptype() == WhereConditionTypeEnum.BETWEEN_NOT) {
                                    //beween value1 and value2
                                    sbSql.append("'" + conditionItem.getVal1() + "' and '" + conditionItem.getVal2() + "'");
                                } else {
                                    //其他当做等于、大于和小于判断
                                    sbSql.append("'" + conditionItem.getVal1() + "'");
                                }
                            } else {
                                //当做数值类型处理
                                //如果列类型是bool，单独转换
                                boolean columnIsBool = column.get().getDatatype() == DataTypeEnum.BOOL;
                                boolean boolValue1 = false;
                                if (columnIsBool) {
                                    if (StringUtils.equalsIgnoreCase(conditionItem.getVal1(), "1") || StringUtils.equalsIgnoreCase(conditionItem.getVal1(), "true"))
                                        boolValue1 = true;
                                }

                                if (column.get().getQccmptype() == WhereConditionTypeEnum.LIKE
                                        || column.get().getQccmptype() == WhereConditionTypeEnum.LIKE_LEFT
                                        || column.get().getQccmptype() == WhereConditionTypeEnum.LIKE_RIGHT) {
                                    //like '%val%'
                                    if (column.get().getQccmptype() == WhereConditionTypeEnum.LIKE_LEFT)
                                        sbSql.append("'%" + (columnIsBool ? (boolValue1 ? "1" : "0") : conditionItem.getVal1()) + "'");
                                    else if (column.get().getQccmptype() == WhereConditionTypeEnum.LIKE_LEFT)
                                        sbSql.append("'" + (columnIsBool ? (boolValue1 ? "1" : "0") : conditionItem.getVal1()) + "%'");
                                    else
                                        sbSql.append("'%" + (columnIsBool ? (boolValue1 ? "1" : "0") : conditionItem.getVal1()) + "%'");
                                } else if (column.get().getQccmptype() == WhereConditionTypeEnum.IN
                                        || column.get().getQccmptype() == WhereConditionTypeEnum.IN_NOT) {
                                    //in、not in (,,,)
                                    sbSql.append("(");
                                    String[] strs = StringSplitUtil.Split(conditionItem.getVal1(), true);
                                    if (strs != null && strs.length > 0x0) {
                                        for (String s : strs) {
                                            sbSql.append(s + ",");
                                        }
                                        //移除最后的逗号，
                                        sbSql.setLength(sbSql.length() - 1);
                                    }
                                    sbSql.append(")");
                                } else if (column.get().getQccmptype() == WhereConditionTypeEnum.BETWEEN
                                        || column.get().getQccmptype() == WhereConditionTypeEnum.BETWEEN_NOT) {
                                    //beween value1 and value2
                                    sbSql.append(conditionItem.getVal1() + " and " + conditionItem.getVal2());
                                } else {
                                    //其他当做等于、大于和小于判断
                                    sbSql.append(columnIsBool ? (boolValue1 ? "1" : "0") : conditionItem.getVal1());
                                }
                            }
                        }
                        //一个字段结束加上and方便连接下一个字段
                        sbSql.append(" and ");
                    } else {
                        //界面传入的查询条件找不到对应的列信息
                        throw new QCPromptException("查询数据的条件中名称为：" + conditionItem.getCode() + "的列信息不存在，无法完成查询操作");
                    }
                }
            }
            //去除最后的 and 
            sbSql.setLength(sbSql.length() - 4);
        }
        //获取列集合中的排序信息
        List<QcDbTableColumn> orderColumns = columnEntitys.stream().filter(p -> p.getQrascorder() != null).sorted(Comparator.comparingInt(QcDbTableColumn::getQrorderidx)).collect(Collectors.toList());
        if (orderColumns != null && orderColumns.size() > 0x0) {
            sbSql.append(" order by ");
            for (QcDbTableColumn column : orderColumns) {
                if (column.getQrascorder())
                    sbSql.append(column.getCode() + " asc,");
                else
                    sbSql.append(column.getCode() + " desc,");
            }
            //去除最后的逗号,
            sbSql.setLength(sbSql.length() - 1);
        }
        //执行Sql语句进行查询
        result.setData(SqlRunnerUtil.executeSelectListSql(dbUrl, dbUser, dbPassword, sbSql.toString()));

        return result;
    }

    /***
     *根据指定的表编码获取查询编辑表单结构；用于前端生成新增或编辑表单的formSchema；
     *
     * @param id 数据库表编码
     * @return qc.module.platform.dto.dbTableData.DBTableDataEditFormDto
     * @author QuCheng Tech
     * @since 2024/3/8
     */
    @GetMapping("/schema")
    public DBTableDataEditFormDto getEditFormSchemaByParam(@RequestParam(required = true) String id) throws QCPromptException, SQLException {
        return getEditFormSchema(id);
    }

    /***
     * 根据指定的表编码获取查询编辑表单结构；用于前端生成新增或编辑表单的formSchema；
     *
     * @param id 数据库表编码
     * @return qc.module.platform.dto.dbTableData.DBTableDataEditFormDto
     * @author QuCheng Tech
     * @since 2024/3/8
     */
    @GetMapping("/schema/{id}")
    public DBTableDataEditFormDto getEditFormSchemaByPath(@PathVariable(required = true) String id) throws QCPromptException, SQLException {
        return getEditFormSchema(id);
    }

    /***
     * 获取指定数据库表的编辑表单结构，返回数据包含表信息和表单列集合信息
     *
     * @param tableCode 数据库表编码
     * @return qc.module.platform.dto.dbTableData.DBTableDataEditFormDto
     * @author QuCheng Tech
     * @since 2024/3/8
     */
    DBTableDataEditFormDto getEditFormSchema(String tableCode) throws QCPromptException, SQLException {
        if (StringUtils.isBlank(tableCode))
            throw new QCPromptException("获取编辑表单结构指定的数据库表编码不能为空");

        DBTableDto table = dbTableService.get(tableCode);
        if (table == null)
            throw new QCPromptException("查获取编辑表单结构的数据库表编码信息不存在");

        DBTableDataEditFormDto result = new DBTableDataEditFormDto();
        result.setTable(table);
        //获取表的表单列信息集合
        List<QcDbTableColumn> columnEntitys = dbTableColumnService.getShowInFormColumnEntitys(tableCode);
        //表的表单列信息集合可以为空
        if (columnEntitys != null && columnEntitys.size() > 0x0) {
            List<DBTableColumnDto> items = new ArrayList<>();

            for (QcDbTableColumn column : columnEntitys) {
                DBTableColumnDto columnDto = DBTableColumnMapper.MAPPER.toDto(column);
                //列的待选择数据需要单独处理
                columnDto.setOptions(dbTableDataService.getColumnOptions(column.getColtype(), column.getValrange()));

                items.add(columnDto);
            }

            result.setItems(items);
        }

        return result;
    }
}
